package com.schoolcloud.serve.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.schoolcloud.common.model.PageDTO;
import com.schoolcloud.common.util.UserContext;
import com.schoolcloud.serve.dto.*;
import com.schoolcloud.serve.entity.*;
import com.schoolcloud.serve.query.SkuAttributeQuery;
import com.schoolcloud.serve.service.*;
import com.schoolcloud.serve.vo.AttributeAssociatedVO;
import com.schoolcloud.serve.vo.SkuItemDetailVO;
import com.schoolcloud.serve.vo.SkuSaleAttListVO;
import com.schoolcolud.daomybatisplus.dto.MpPageUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class SkuInteractionServiceImpl implements SkuInteractionService {
    private final SkuService skuService;
    private final SpuService spuService;
    private final SkuAttrGroupService skuAttrGroupService;
    private final AttrGroupAssociatedService attrGroupAssociatedService;
    private final GroupAttrValueService groupAttrValueService;
    private final SkuAttributeService skuAttributeService;
    private final SkuSaleAttrValueService skuSaleAttrValueService;
    private final SkuPictureService skuPictureService;

    @Override
    @Transactional
    public void createGoods(GoodsCreateDTO goodsSaveDTO) {
//        保存spu的信息
        Spu spuInfo = goodsSaveDTO.getSpuInfo();
        spuInfo.setCreateTime(LocalDateTime.now());
        spuInfo.setUserId(UserContext.getUserToInteger());
        spuService.save(spuInfo);
//        保存规格参数属性值信息
        List<GroupAttributeValuesDTO> groupAttributeList = goodsSaveDTO.getGroupAttributeList();
        if (CollUtil.isNotEmpty(groupAttributeList)) {
            groupAttributeList.forEach(item -> {
//                保存规格参数属性值信息
                List<AttributeAndValuesDTO> attributes = item.getAttributes();
                if (CollUtil.isNotEmpty(attributes)) {
                    attributes.forEach(attr -> {
                        List<String> attributeValues = attr.getAttributeValues();
                        if (CollUtil.isNotEmpty(attributeValues)) {
                            attributeValues.forEach(attrValue -> {
//                                保存属性值信息
                                GroupAttrValue groupAttrValue = new GroupAttrValue();
                                groupAttrValue.setAttributeValue(attrValue);
                                groupAttrValue.setSpuId(spuInfo.getSpuId());
                                groupAttrValue.setAttributeName(attr.getAttrName());
                                groupAttrValue.setAttrId(attr.getAttributeId());
                                groupAttrValue.setQuickShow(attr.getQuickShow());
                                groupAttrValueService.save(groupAttrValue);
                            });
                        }
                    });
                }
            });
        }
//        保存sku信息以及sku销售属性信息
        List<SkuAndSaleAttributeAndPictureDTO> skuList = goodsSaveDTO.getSkuList();
        if (CollUtil.isNotEmpty(skuList)) {
            skuList.forEach(item -> {
                item.setSpuId(spuInfo.getSpuId());
                skuService.save(item);
                List<SaleAttributeAndValue> saleAttributeList = item.getSaleAttributeList();
                if (CollUtil.isNotEmpty(saleAttributeList)) {
                    saleAttributeList.forEach(attr -> {
                        SkuSaleAttrValue skuSaleAttrValue = new SkuSaleAttrValue();
                        skuSaleAttrValue.setSkuId(item.getSkuId());
                        skuSaleAttrValue.setAttrId(attr.getAttributeId());
                        skuSaleAttrValue.setAttrName(attr.getAttrName());
                        skuSaleAttrValue.setAttrValue(attr.getAttrValue());
                        skuSaleAttrValueService.save(skuSaleAttrValue);
                    });
                }
//                保存图集信息
                List<String> skuPictureList = item.getSkuPictureList();
                if (CollUtil.isNotEmpty(skuPictureList)) {
                    skuPictureList.forEach(fileItem -> {
                        SkuPicture skuPicture = new SkuPicture();
                        skuPicture.setSkuId(item.getSkuId());
                        skuPicture.setFileUrl(fileItem);
                        skuPictureService.save(skuPicture);
                    });
                }
            });
        }
    }

    @Override
    public void modifySku(SkuModifyDTO dto) {
        skuService.updateById(dto);
        List<String> skuPictureList = dto.getSkuPictureList();
        if (CollUtil.isNotEmpty(skuPictureList)) {
//            先删除之前的图片信息
            skuPictureService.removeBySkuId(dto.getSkuId());
            skuPictureList.forEach(fileItem -> {
                SkuPicture skuPicture = new SkuPicture();
                skuPicture.setSkuId(dto.getSkuId());
                skuPicture.setFileUrl(fileItem);
                skuPictureService.save(skuPicture);
            });
        }
    }

    @Override
    public SkuModifyDTO getSkuModifyDTO(String id) {
        Sku byId = skuService.getById(id);
        if (byId == null) return null;
        List<String> urls = skuPictureService.getFileUrlListBySkuId(id);
        SkuModifyDTO dto = new SkuModifyDTO();
        BeanUtils.copyProperties(byId, dto);
        dto.setSkuPictureList(urls);
        return dto;
    }

    @Override
    public PageDTO<AttributeAssociatedVO> getSkuAttributePageByGroup(SkuAttributeQuery query) {
        String categoryId = query.getCategoryId();
        PageDTO<AttributeAssociatedVO> of;
        if (query.getShowAll()) {
//            查询全部属性
            Page<SkuAttribute> skuAttributePage = skuAttributeService.getSkuAttributeMPPage(query);
            of = MpPageUtil.of(skuAttributePage, AttributeAssociatedVO.class);
//            并且标注哪些属性已经被当前分组关联了
            String groupId = query.getGroupId();
            List<Integer> attributeIdsByGroupId = attrGroupAssociatedService.getAttributeIdsByGroupId(groupId);
            of.getList().forEach(item -> {
                if (attributeIdsByGroupId.contains(item.getAttributeId())) {
                    item.setIsAssociated(true);
                }
            });
        } else {
//            查询没有被关联的属性
            List<Integer> integers = attrGroupAssociatedService.lambdaQuery().select(AttrGroupAssociated::getAttributeId).list().stream().map(AttrGroupAssociated::getAttributeId).toList();
            Page<SkuAttribute> page = skuAttributeService.lambdaQuery().notIn(SkuAttribute::getAttributeId, integers).eq(StrUtil.isNotBlank(categoryId), SkuAttribute::getCategoryId, categoryId).eq(StrUtil.isNotBlank(query.getAttributeType()), SkuAttribute::getAttrType, query.getAttributeType()).page(query.toMpPage());
            of = MpPageUtil.of(page, AttributeAssociatedVO.class);
        }
        return of;
    }



    @Override
    public List<GroupAttributeValuesDTO> getAttrGroupAndValuesByCategoryIdAndSpuId(String categoryId, String spuId) {
        List<SkuAttrGroup> attrGroupByCategoryId = skuAttrGroupService.getAttrGroupByCategoryId(categoryId);
        return attrGroupByCategoryId.stream().map(item -> {
//            封装这个分组下的属性集合
            GroupAttributeValuesDTO dto = new GroupAttributeValuesDTO();
            BeanUtils.copyProperties(item, dto);
//            查找关联表，找出这个分组下的属性id集合
            List<Integer> attributeIds = attrGroupAssociatedService.getAttributeIdsByGroupId(item.getGroupId().toString());
//            根据这些id查出属性的属性信息
            List<SkuAttribute> skuAttributes = skuAttributeService.listByIds(attributeIds);
            dto.setAttributes(skuAttributes.stream().map(attr -> {
                AttributeAndValuesDTO attributeAndValuesDTO = new AttributeAndValuesDTO();
                BeanUtils.copyProperties(attr, attributeAndValuesDTO);
                if (spuId!=null){
                    List<String> attributeValuesByAttributeIdAndSpuId = groupAttrValueService.getAttributeValuesByAttributeIdAndSpuId(attr.getAttributeId().toString(), spuId);
                    attributeAndValuesDTO.setAttributeValues(attributeValuesByAttributeIdAndSpuId);
                }
                return attributeAndValuesDTO;
            }).toList());
            return dto;
        }).collect(Collectors.toList());
    }

    @Override
    public SkuItemDetailVO getSkuDetail(String id) {
        SkuItemDetailVO vo = new SkuItemDetailVO();
//        查询sku基本信息
        Sku skuInfo = skuService.getById(id);
        if (skuInfo==null){
            return null;
        }
        vo.setSku(skuInfo);
//        查询spu信息
        Spu spuInfo = spuService.getById(skuInfo.getSpuId());
        vo.setSpu(spuInfo);
//        查询sku图集
        List<String> skuPictureList = skuPictureService.getFileUrlListBySkuId(id);
        vo.setSkuPictureList(skuPictureList);
//        查询当前分类下的的所有属性信息
        List<GroupAttributeValuesDTO> attrGroupAndValuesByCategoryId = getAttrGroupAndValuesByCategoryIdAndSpuId(spuInfo.getCategoryId().toString(),spuInfo.getSpuId().toString());
//        查询当期分组下的每一个属性下的属性值
        attrGroupAndValuesByCategoryId.forEach(item -> {

        });
        vo.setGroupAttributeValues(attrGroupAndValuesByCategoryId);
//        查询当前分类下的销售属性信息，并且查询当前spu下的所有销售属性的取值以及哪些sku具有销售属性值
        List<SkuAttribute> saleSkuAttributeList = skuAttributeService.getSaleSkuAttributeByCategoryId(spuInfo.getCategoryId().toString());
//        遍历每一个销售属性。需要查出该销售属性的属性值集合，以及sku集合
        List<SkuSaleAttListVO> skuSaleAttListVOS = saleSkuAttributeList.stream().map(item -> {
//            查询当前属性下的属性值列表
            List<String> values = skuSaleAttrValueService.getValueListByAttrId(item.getAttributeId());
            SkuSaleAttListVO outerClass = new SkuSaleAttListVO();
            BeanUtils.copyProperties(item, outerClass);
//            遍历这些属性值查找出该属性值对应的sku集合
            List<SkuSaleAttListVO.SkuSaleAttrWithValueWithSkuIdsVO> skuSaleAttrWithValueWithSkuIdsVOS = values.stream().map(value -> {
                SkuSaleAttListVO.SkuSaleAttrWithValueWithSkuIdsVO innerClass =
                        new SkuSaleAttListVO.SkuSaleAttrWithValueWithSkuIdsVO();
                innerClass.setAttributeValue(value);
//                查询skuId集合
                List<Integer> skuIds = skuSaleAttrValueService.getSkuIdsByValue(value);
//                初始化选中skuId集合（当前sku）
                if(skuIds.contains(Integer.parseInt(id))){
                    outerClass.setSelectSkuList(skuIds);
                }
                innerClass.setSkuIds(skuIds);
                return innerClass;
            }).toList();
            outerClass.setSkuSaleAttrWithValueWithSkuIdsVOList(skuSaleAttrWithValueWithSkuIdsVOS);
            return outerClass;
        }).toList();
        vo.setSkuSaleAttrWithValueWithSkuIdsVOList(skuSaleAttListVOS);
        return vo;
    }

}
